/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using MaxwithnanWindow3Stride2Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::MaxWithNan, pooling::Forward>;
TYPED_TEST_SUITE(MaxwithnanWindow3Stride2Forward, GTestTypePairs);
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x5x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  9.,  10., 17., 19.,
                                         20., 22., 24., 25.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x5x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13., 15., 23., 25.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x5x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13., 14., 17., 18., 19., 20.,
                                         33., 34., 37., 38., 39., 40.,
                                         43., 44., 47., 48., 49., 50.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x5x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {25., 26., 29., 30.,
                                         45., 46., 49., 50.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x5x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25., 26., 27., 28., 33., 34., 35., 36., 37., 38., 39., 40.,
      65., 66., 67., 68., 73., 74., 75., 76., 77., 78., 79., 80.,
      85., 86., 87., 88., 93., 94., 95., 96., 97., 98., 99., 100.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x5x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {49., 50., 51., 52., 57., 58.,
                                         59., 60., 89., 90., 91., 92.,
                                         97., 98., 99., 100.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x5x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9.,  11., 12., 21., 23.,
                                         24., 27., 29., 30.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x5x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 17., 27., 29.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x5x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17., 18., 21., 22., 23., 24.,
                                         41., 42., 45., 46., 47., 48.,
                                         53., 54., 57., 58., 59., 60.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x5x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 33., 34.,
                                         53., 54., 57., 58.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x5x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      81.,  82.,  83.,  84.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      105., 106., 107., 108., 113., 114., 115., 116., 117., 118., 119., 120.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x5x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57.,  58.,  59.,  60.,  65.,  66.,
                                         67.,  68.,  105., 106., 107., 108.,
                                         113., 114., 115., 116.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x5x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11., 13., 15., 16., 27., 29.,
                                         31., 32., 35., 37., 39., 40.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x5x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 21., 23., 35., 37., 39.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x5x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21., 22., 25., 26., 29., 30., 31., 32., 53., 54., 57., 58.,
      61., 62., 63., 64., 69., 70., 73., 74., 77., 78., 79., 80.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x5x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 38., 41., 42., 45., 46.,
                                         69., 70., 73., 74., 77., 78.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x5x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41.,  42.,  43.,  44.,  49.,  50.,  51.,  52.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  105., 106., 107., 108., 113., 114., 115., 116.,
      121., 122., 123., 124., 125., 126., 127., 128., 137., 138., 139., 140.,
      145., 146., 147., 148., 153., 154., 155., 156., 157., 158., 159., 160.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x5x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  89.,  90.,  91.,  92.,
      137., 138., 139., 140., 145., 146., 147., 148., 153., 154., 155., 156.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x6x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12., 14., 15., 22., 24.,
                                         25., 27., 29., 30.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x6x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13., 15., 23., 25.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x6x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23., 24., 27., 28., 29., 30.,
                                         43., 44., 47., 48., 49., 50.,
                                         53., 54., 57., 58., 59., 60.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x6x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {25., 26., 29., 30.,
                                         45., 46., 49., 50.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x6x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      85.,  86.,  87.,  88.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      105., 106., 107., 108., 113., 114., 115., 116., 117., 118., 119., 120.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x6x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {49., 50., 51., 52., 57., 58.,
                                         59., 60., 89., 90., 91., 92.,
                                         97., 98., 99., 100.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 17., 18., 27., 29.,
                                         30., 33., 35., 36.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 17., 27., 29.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 33., 34., 35., 36.,
                                         53., 54., 57., 58., 59., 60.,
                                         65., 66., 69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 33., 34.,
                                         53., 54., 57., 58.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      105., 106., 107., 108., 113., 114., 115., 116., 117., 118., 119., 120.,
      129., 130., 131., 132., 137., 138., 139., 140., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57.,  58.,  59.,  60.,  65.,  66.,
                                         67.,  68.,  105., 106., 107., 108.,
                                         113., 114., 115., 116.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 21., 23., 24., 35., 37.,
                                         39., 40., 43., 45., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 21., 23., 35., 37., 39.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37., 38., 41., 42., 45., 46., 47., 48., 69., 70., 73., 74.,
      77., 78., 79., 80., 85., 86., 89., 90., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 38., 41., 42., 45., 46.,
                                         69., 70., 73., 74., 77., 78.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  137., 138., 139., 140., 145., 146., 147., 148.,
      153., 154., 155., 156., 157., 158., 159., 160., 169., 170., 171., 172.,
      177., 178., 179., 180., 185., 186., 187., 188., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  89.,  90.,  91.,  92.,
      137., 138., 139., 140., 145., 146., 147., 148., 153., 154., 155., 156.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x8x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12., 14., 15., 22., 24., 25.,
                                         32., 34., 35., 37., 39., 40.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x8x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13., 15., 23., 25., 33., 35.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x8x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23., 24., 27., 28., 29., 30., 43., 44., 47., 48., 49., 50.,
      63., 64., 67., 68., 69., 70., 73., 74., 77., 78., 79., 80.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x8x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {25., 26., 29., 30., 45., 46.,
                                         49., 50., 65., 66., 69., 70.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x8x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      85.,  86.,  87.,  88.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      125., 126., 127., 128., 133., 134., 135., 136., 137., 138., 139., 140.,
      145., 146., 147., 148., 153., 154., 155., 156., 157., 158., 159., 160.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x8x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49., 50., 51., 52.,  57.,  58.,  59.,  60.,  89.,  90.,  91.,  92.,
      97., 98., 99., 100., 129., 130., 131., 132., 137., 138., 139., 140.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 17., 18., 27., 29., 30.,
                                         39., 41., 42., 45., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 17., 27., 29., 39., 41.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29., 30., 33., 34., 35., 36., 53., 54., 57., 58., 59., 60.,
      77., 78., 81., 82., 83., 84., 89., 90., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 33., 34., 53., 54.,
                                         57., 58., 77., 78., 81., 82.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      105., 106., 107., 108., 113., 114., 115., 116., 117., 118., 119., 120.,
      153., 154., 155., 156., 161., 162., 163., 164., 165., 166., 167., 168.,
      177., 178., 179., 180., 185., 186., 187., 188., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  105., 106., 107., 108.,
      113., 114., 115., 116., 153., 154., 155., 156., 161., 162., 163., 164.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 21., 23., 24., 35., 37.,
                                         39., 40., 51., 53., 55., 56.,
                                         59., 61., 63., 64.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 21., 23., 35., 37.,
                                         39., 51., 53., 55.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  41.,  42.,  45.,  46.,  47.,  48.,  69.,  70.,  73.,
      74.,  77.,  78.,  79.,  80.,  101., 102., 105., 106., 109., 110.,
      111., 112., 117., 118., 121., 122., 125., 126., 127., 128.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37.,  38.,  41.,  42.,  45.,  46.,
                                         69.,  70.,  73.,  74.,  77.,  78.,
                                         101., 102., 105., 106., 109., 110.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  89.,  90.,  91.,
      92.,  93.,  94.,  95.,  96.,  137., 138., 139., 140., 145., 146.,
      147., 148., 153., 154., 155., 156., 157., 158., 159., 160., 201.,
      202., 203., 204., 209., 210., 211., 212., 217., 218., 219., 220.,
      221., 222., 223., 224., 233., 234., 235., 236., 241., 242., 243.,
      244., 249., 250., 251., 252., 253., 254., 255., 256.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  89.,  90.,  91.,  92.,
      137., 138., 139., 140., 145., 146., 147., 148., 153., 154., 155., 156.,
      201., 202., 203., 204., 209., 210., 211., 212., 217., 218., 219., 220.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x5x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  9.,  10., 17., 19., 20., 22., 24., 25., 32., 34., 35., 42., 44.,
      45., 47., 49., 50., 57., 59., 60., 67., 69., 70., 72., 74., 75.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x5x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13., 15., 23., 25., 38., 40.,
                                         48., 50., 63., 65., 73., 75.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x5x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13.,  14.,  17.,  18.,  19.,  20.,  33.,  34.,  37.,  38.,  39.,
      40.,  43.,  44.,  47.,  48.,  49.,  50.,  63.,  64.,  67.,  68.,
      69.,  70.,  83.,  84.,  87.,  88.,  89.,  90.,  93.,  94.,  97.,
      98.,  99.,  100., 113., 114., 117., 118., 119., 120., 133., 134.,
      137., 138., 139., 140., 143., 144., 147., 148., 149., 150.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x5x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25., 26., 29., 30.,  45.,  46.,  49.,  50.,  75.,  76.,  79.,  80.,
      95., 96., 99., 100., 125., 126., 129., 130., 145., 146., 149., 150.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x5x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,  26.,  27.,  28.,  33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,
      65.,  66.,  67.,  68.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,
      85.,  86.,  87.,  88.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      125., 126., 127., 128., 133., 134., 135., 136., 137., 138., 139., 140.,
      165., 166., 167., 168., 173., 174., 175., 176., 177., 178., 179., 180.,
      185., 186., 187., 188., 193., 194., 195., 196., 197., 198., 199., 200.,
      225., 226., 227., 228., 233., 234., 235., 236., 237., 238., 239., 240.,
      265., 266., 267., 268., 273., 274., 275., 276., 277., 278., 279., 280.,
      285., 286., 287., 288., 293., 294., 295., 296., 297., 298., 299., 300.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x5x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  50.,  51.,  52.,  57.,  58.,  59.,  60.,  89.,  90.,  91.,  92.,
      97.,  98.,  99.,  100., 149., 150., 151., 152., 157., 158., 159., 160.,
      189., 190., 191., 192., 197., 198., 199., 200., 249., 250., 251., 252.,
      257., 258., 259., 260., 289., 290., 291., 292., 297., 298., 299., 300.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x5x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9.,  11., 12., 21., 23., 24., 27., 29., 30., 39., 41., 42., 51., 53.,
      54., 57., 59., 60., 69., 71., 72., 81., 83., 84., 87., 89., 90.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x5x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 17., 27., 29., 45., 47.,
                                         57., 59., 75., 77., 87., 89.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x5x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.,  18.,  21.,  22.,  23.,  24.,  41.,  42.,  45.,  46.,  47.,
      48.,  53.,  54.,  57.,  58.,  59.,  60.,  77.,  78.,  81.,  82.,
      83.,  84.,  101., 102., 105., 106., 107., 108., 113., 114., 117.,
      118., 119., 120., 137., 138., 141., 142., 143., 144., 161., 162.,
      165., 166., 167., 168., 173., 174., 177., 178., 179., 180.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x5x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  33.,  34.,  53.,  54.,  57.,  58.,  89.,  90.,  93.,  94.,
      113., 114., 117., 118., 149., 150., 153., 154., 173., 174., 177., 178.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x5x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      81.,  82.,  83.,  84.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      105., 106., 107., 108., 113., 114., 115., 116., 117., 118., 119., 120.,
      153., 154., 155., 156., 161., 162., 163., 164., 165., 166., 167., 168.,
      201., 202., 203., 204., 209., 210., 211., 212., 213., 214., 215., 216.,
      225., 226., 227., 228., 233., 234., 235., 236., 237., 238., 239., 240.,
      273., 274., 275., 276., 281., 282., 283., 284., 285., 286., 287., 288.,
      321., 322., 323., 324., 329., 330., 331., 332., 333., 334., 335., 336.,
      345., 346., 347., 348., 353., 354., 355., 356., 357., 358., 359., 360.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x5x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  105., 106., 107., 108.,
      113., 114., 115., 116., 177., 178., 179., 180., 185., 186., 187., 188.,
      225., 226., 227., 228., 233., 234., 235., 236., 297., 298., 299., 300.,
      305., 306., 307., 308., 345., 346., 347., 348., 353., 354., 355., 356.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x5x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 13., 15., 16., 27.,  29.,  31.,  32.,  35.,  37.,  39.,  40.,
      51., 53., 55., 56., 67.,  69.,  71.,  72.,  75.,  77.,  79.,  80.,
      91., 93., 95., 96., 107., 109., 111., 112., 115., 117., 119., 120.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x5x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 21.,  23.,  35.,  37.,  39.,
                                         59., 61.,  63.,  75.,  77.,  79.,
                                         99., 101., 103., 115., 117., 119.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x5x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21.,  22.,  25.,  26.,  29.,  30.,  31.,  32.,  53.,  54.,  57.,  58.,
      61.,  62.,  63.,  64.,  69.,  70.,  73.,  74.,  77.,  78.,  79.,  80.,
      101., 102., 105., 106., 109., 110., 111., 112., 133., 134., 137., 138.,
      141., 142., 143., 144., 149., 150., 153., 154., 157., 158., 159., 160.,
      181., 182., 185., 186., 189., 190., 191., 192., 213., 214., 217., 218.,
      221., 222., 223., 224., 229., 230., 233., 234., 237., 238., 239., 240.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x5x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  41.,  42.,  45.,  46.,  69.,  70.,  73.,  74.,  77.,  78.,
      117., 118., 121., 122., 125., 126., 149., 150., 153., 154., 157., 158.,
      197., 198., 201., 202., 205., 206., 229., 230., 233., 234., 237., 238.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x5x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41.,  42.,  43.,  44.,  49.,  50.,  51.,  52.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  105., 106., 107., 108., 113., 114., 115., 116.,
      121., 122., 123., 124., 125., 126., 127., 128., 137., 138., 139., 140.,
      145., 146., 147., 148., 153., 154., 155., 156., 157., 158., 159., 160.,
      201., 202., 203., 204., 209., 210., 211., 212., 217., 218., 219., 220.,
      221., 222., 223., 224., 265., 266., 267., 268., 273., 274., 275., 276.,
      281., 282., 283., 284., 285., 286., 287., 288., 297., 298., 299., 300.,
      305., 306., 307., 308., 313., 314., 315., 316., 317., 318., 319., 320.,
      361., 362., 363., 364., 369., 370., 371., 372., 377., 378., 379., 380.,
      381., 382., 383., 384., 425., 426., 427., 428., 433., 434., 435., 436.,
      441., 442., 443., 444., 445., 446., 447., 448., 457., 458., 459., 460.,
      465., 466., 467., 468., 473., 474., 475., 476., 477., 478., 479., 480.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x5x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  89.,  90.,  91.,  92.,
      137., 138., 139., 140., 145., 146., 147., 148., 153., 154., 155., 156.,
      233., 234., 235., 236., 241., 242., 243., 244., 249., 250., 251., 252.,
      297., 298., 299., 300., 305., 306., 307., 308., 313., 314., 315., 316.,
      393., 394., 395., 396., 401., 402., 403., 404., 409., 410., 411., 412.,
      457., 458., 459., 460., 465., 466., 467., 468., 473., 474., 475., 476.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x6x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12., 14., 15., 22., 24., 25., 27., 29., 30., 42., 44., 45., 52., 54.,
      55., 57., 59., 60., 72., 74., 75., 82., 84., 85., 87., 89., 90.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x6x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13., 15., 23., 25., 43., 45.,
                                         53., 55., 73., 75., 83., 85.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x6x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23.,  24.,  27.,  28.,  29.,  30.,  43.,  44.,  47.,  48.,  49.,
      50.,  53.,  54.,  57.,  58.,  59.,  60.,  83.,  84.,  87.,  88.,
      89.,  90.,  103., 104., 107., 108., 109., 110., 113., 114., 117.,
      118., 119., 120., 143., 144., 147., 148., 149., 150., 163., 164.,
      167., 168., 169., 170., 173., 174., 177., 178., 179., 180.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x6x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,  26.,  29.,  30.,  45.,  46.,  49.,  50.,  85.,  86.,  89.,  90.,
      105., 106., 109., 110., 145., 146., 149., 150., 165., 166., 169., 170.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x6x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      85.,  86.,  87.,  88.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      105., 106., 107., 108., 113., 114., 115., 116., 117., 118., 119., 120.,
      165., 166., 167., 168., 173., 174., 175., 176., 177., 178., 179., 180.,
      205., 206., 207., 208., 213., 214., 215., 216., 217., 218., 219., 220.,
      225., 226., 227., 228., 233., 234., 235., 236., 237., 238., 239., 240.,
      285., 286., 287., 288., 293., 294., 295., 296., 297., 298., 299., 300.,
      325., 326., 327., 328., 333., 334., 335., 336., 337., 338., 339., 340.,
      345., 346., 347., 348., 353., 354., 355., 356., 357., 358., 359., 360.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x6x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  50.,  51.,  52.,  57.,  58.,  59.,  60.,  89.,  90.,  91.,  92.,
      97.,  98.,  99.,  100., 169., 170., 171., 172., 177., 178., 179., 180.,
      209., 210., 211., 212., 217., 218., 219., 220., 289., 290., 291., 292.,
      297., 298., 299., 300., 329., 330., 331., 332., 337., 338., 339., 340.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 17., 18., 27., 29., 30., 33., 35., 36.,  51.,  53.,  54.,  63., 65.,
      66., 69., 71., 72., 87., 89., 90., 99., 101., 102., 105., 107., 108.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 17., 27., 29., 51., 53.,
                                         63., 65., 87., 89., 99., 101.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  33.,  34.,  35.,  36.,  53.,  54.,  57.,  58.,  59.,
      60.,  65.,  66.,  69.,  70.,  71.,  72.,  101., 102., 105., 106.,
      107., 108., 125., 126., 129., 130., 131., 132., 137., 138., 141.,
      142., 143., 144., 173., 174., 177., 178., 179., 180., 197., 198.,
      201., 202., 203., 204., 209., 210., 213., 214., 215., 216.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  33.,  34.,  53.,  54.,  57.,  58.,  101., 102., 105., 106.,
      125., 126., 129., 130., 173., 174., 177., 178., 197., 198., 201., 202.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      105., 106., 107., 108., 113., 114., 115., 116., 117., 118., 119., 120.,
      129., 130., 131., 132., 137., 138., 139., 140., 141., 142., 143., 144.,
      201., 202., 203., 204., 209., 210., 211., 212., 213., 214., 215., 216.,
      249., 250., 251., 252., 257., 258., 259., 260., 261., 262., 263., 264.,
      273., 274., 275., 276., 281., 282., 283., 284., 285., 286., 287., 288.,
      345., 346., 347., 348., 353., 354., 355., 356., 357., 358., 359., 360.,
      393., 394., 395., 396., 401., 402., 403., 404., 405., 406., 407., 408.,
      417., 418., 419., 420., 425., 426., 427., 428., 429., 430., 431., 432.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  105., 106., 107., 108.,
      113., 114., 115., 116., 201., 202., 203., 204., 209., 210., 211., 212.,
      249., 250., 251., 252., 257., 258., 259., 260., 345., 346., 347., 348.,
      353., 354., 355., 356., 393., 394., 395., 396., 401., 402., 403., 404.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  21.,  23.,  24.,  35.,  37.,  39.,  40.,  43.,  45.,  47.,  48.,
      67.,  69.,  71.,  72.,  83.,  85.,  87.,  88.,  91.,  93.,  95.,  96.,
      115., 117., 119., 120., 131., 133., 135., 136., 139., 141., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19.,  21.,  23.,  35.,  37.,  39.,
                                         67.,  69.,  71.,  83.,  85.,  87.,
                                         115., 117., 119., 131., 133., 135.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  41.,  42.,  45.,  46.,  47.,  48.,  69.,  70.,  73.,  74.,
      77.,  78.,  79.,  80.,  85.,  86.,  89.,  90.,  93.,  94.,  95.,  96.,
      133., 134., 137., 138., 141., 142., 143., 144., 165., 166., 169., 170.,
      173., 174., 175., 176., 181., 182., 185., 186., 189., 190., 191., 192.,
      229., 230., 233., 234., 237., 238., 239., 240., 261., 262., 265., 266.,
      269., 270., 271., 272., 277., 278., 281., 282., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  41.,  42.,  45.,  46.,  69.,  70.,  73.,  74.,  77.,  78.,
      133., 134., 137., 138., 141., 142., 165., 166., 169., 170., 173., 174.,
      229., 230., 233., 234., 237., 238., 261., 262., 265., 266., 269., 270.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  137., 138., 139., 140., 145., 146., 147., 148.,
      153., 154., 155., 156., 157., 158., 159., 160., 169., 170., 171., 172.,
      177., 178., 179., 180., 185., 186., 187., 188., 189., 190., 191., 192.,
      265., 266., 267., 268., 273., 274., 275., 276., 281., 282., 283., 284.,
      285., 286., 287., 288., 329., 330., 331., 332., 337., 338., 339., 340.,
      345., 346., 347., 348., 349., 350., 351., 352., 361., 362., 363., 364.,
      369., 370., 371., 372., 377., 378., 379., 380., 381., 382., 383., 384.,
      457., 458., 459., 460., 465., 466., 467., 468., 473., 474., 475., 476.,
      477., 478., 479., 480., 521., 522., 523., 524., 529., 530., 531., 532.,
      537., 538., 539., 540., 541., 542., 543., 544., 553., 554., 555., 556.,
      561., 562., 563., 564., 569., 570., 571., 572., 573., 574., 575., 576.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  89.,  90.,  91.,  92.,
      137., 138., 139., 140., 145., 146., 147., 148., 153., 154., 155., 156.,
      265., 266., 267., 268., 273., 274., 275., 276., 281., 282., 283., 284.,
      329., 330., 331., 332., 337., 338., 339., 340., 345., 346., 347., 348.,
      457., 458., 459., 460., 465., 466., 467., 468., 473., 474., 475., 476.,
      521., 522., 523., 524., 529., 530., 531., 532., 537., 538., 539., 540.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x8x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12., 14., 15., 22.,  24.,  25.,  32.,  34.,  35.,  37.,  39.,  40.,
      52., 54., 55., 62.,  64.,  65.,  72.,  74.,  75.,  77.,  79.,  80.,
      92., 94., 95., 102., 104., 105., 112., 114., 115., 117., 119., 120.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x8x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13., 15., 23.,  25.,  33.,  35.,
                                         53., 55., 63.,  65.,  73.,  75.,
                                         93., 95., 103., 105., 113., 115.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x8x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23.,  24.,  27.,  28.,  29.,  30.,  43.,  44.,  47.,  48.,  49.,  50.,
      63.,  64.,  67.,  68.,  69.,  70.,  73.,  74.,  77.,  78.,  79.,  80.,
      103., 104., 107., 108., 109., 110., 123., 124., 127., 128., 129., 130.,
      143., 144., 147., 148., 149., 150., 153., 154., 157., 158., 159., 160.,
      183., 184., 187., 188., 189., 190., 203., 204., 207., 208., 209., 210.,
      223., 224., 227., 228., 229., 230., 233., 234., 237., 238., 239., 240.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x8x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,  26.,  29.,  30.,  45.,  46.,  49.,  50.,  65.,  66.,  69.,  70.,
      105., 106., 109., 110., 125., 126., 129., 130., 145., 146., 149., 150.,
      185., 186., 189., 190., 205., 206., 209., 210., 225., 226., 229., 230.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x8x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      85.,  86.,  87.,  88.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      125., 126., 127., 128., 133., 134., 135., 136., 137., 138., 139., 140.,
      145., 146., 147., 148., 153., 154., 155., 156., 157., 158., 159., 160.,
      205., 206., 207., 208., 213., 214., 215., 216., 217., 218., 219., 220.,
      245., 246., 247., 248., 253., 254., 255., 256., 257., 258., 259., 260.,
      285., 286., 287., 288., 293., 294., 295., 296., 297., 298., 299., 300.,
      305., 306., 307., 308., 313., 314., 315., 316., 317., 318., 319., 320.,
      365., 366., 367., 368., 373., 374., 375., 376., 377., 378., 379., 380.,
      405., 406., 407., 408., 413., 414., 415., 416., 417., 418., 419., 420.,
      445., 446., 447., 448., 453., 454., 455., 456., 457., 458., 459., 460.,
      465., 466., 467., 468., 473., 474., 475., 476., 477., 478., 479., 480.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x8x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  50.,  51.,  52.,  57.,  58.,  59.,  60.,  89.,  90.,  91.,  92.,
      97.,  98.,  99.,  100., 129., 130., 131., 132., 137., 138., 139., 140.,
      209., 210., 211., 212., 217., 218., 219., 220., 249., 250., 251., 252.,
      257., 258., 259., 260., 289., 290., 291., 292., 297., 298., 299., 300.,
      369., 370., 371., 372., 377., 378., 379., 380., 409., 410., 411., 412.,
      417., 418., 419., 420., 449., 450., 451., 452., 457., 458., 459., 460.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15.,  17.,  18.,  27.,  29.,  30.,  39.,  41.,  42.,  45.,  47.,  48.,
      63.,  65.,  66.,  75.,  77.,  78.,  87.,  89.,  90.,  93.,  95.,  96.,
      111., 113., 114., 123., 125., 126., 135., 137., 138., 141., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15.,  17.,  27.,  29.,  39.,  41.,
                                         63.,  65.,  75.,  77.,  87.,  89.,
                                         111., 113., 123., 125., 135., 137.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  33.,  34.,  35.,  36.,  53.,  54.,  57.,  58.,  59.,  60.,
      77.,  78.,  81.,  82.,  83.,  84.,  89.,  90.,  93.,  94.,  95.,  96.,
      125., 126., 129., 130., 131., 132., 149., 150., 153., 154., 155., 156.,
      173., 174., 177., 178., 179., 180., 185., 186., 189., 190., 191., 192.,
      221., 222., 225., 226., 227., 228., 245., 246., 249., 250., 251., 252.,
      269., 270., 273., 274., 275., 276., 281., 282., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  33.,  34.,  53.,  54.,  57.,  58.,  77.,  78.,  81.,  82.,
      125., 126., 129., 130., 149., 150., 153., 154., 173., 174., 177., 178.,
      221., 222., 225., 226., 245., 246., 249., 250., 269., 270., 273., 274.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      105., 106., 107., 108., 113., 114., 115., 116., 117., 118., 119., 120.,
      153., 154., 155., 156., 161., 162., 163., 164., 165., 166., 167., 168.,
      177., 178., 179., 180., 185., 186., 187., 188., 189., 190., 191., 192.,
      249., 250., 251., 252., 257., 258., 259., 260., 261., 262., 263., 264.,
      297., 298., 299., 300., 305., 306., 307., 308., 309., 310., 311., 312.,
      345., 346., 347., 348., 353., 354., 355., 356., 357., 358., 359., 360.,
      369., 370., 371., 372., 377., 378., 379., 380., 381., 382., 383., 384.,
      441., 442., 443., 444., 449., 450., 451., 452., 453., 454., 455., 456.,
      489., 490., 491., 492., 497., 498., 499., 500., 501., 502., 503., 504.,
      537., 538., 539., 540., 545., 546., 547., 548., 549., 550., 551., 552.,
      561., 562., 563., 564., 569., 570., 571., 572., 573., 574., 575., 576.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  105., 106., 107., 108.,
      113., 114., 115., 116., 153., 154., 155., 156., 161., 162., 163., 164.,
      249., 250., 251., 252., 257., 258., 259., 260., 297., 298., 299., 300.,
      305., 306., 307., 308., 345., 346., 347., 348., 353., 354., 355., 356.,
      441., 442., 443., 444., 449., 450., 451., 452., 489., 490., 491., 492.,
      497., 498., 499., 500., 537., 538., 539., 540., 545., 546., 547., 548.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  21.,  23.,  24.,  35.,  37.,  39.,  40.,  51.,  53.,  55.,  56.,
      59.,  61.,  63.,  64.,  83.,  85.,  87.,  88.,  99.,  101., 103., 104.,
      115., 117., 119., 120., 123., 125., 127., 128., 147., 149., 151., 152.,
      163., 165., 167., 168., 179., 181., 183., 184., 187., 189., 191., 192.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  21.,  23.,  35.,  37.,  39.,  51.,  53.,  55.,
      83.,  85.,  87.,  99.,  101., 103., 115., 117., 119.,
      147., 149., 151., 163., 165., 167., 179., 181., 183.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  41.,  42.,  45.,  46.,  47.,  48.,  69.,  70.,  73.,  74.,
      77.,  78.,  79.,  80.,  101., 102., 105., 106., 109., 110., 111., 112.,
      117., 118., 121., 122., 125., 126., 127., 128., 165., 166., 169., 170.,
      173., 174., 175., 176., 197., 198., 201., 202., 205., 206., 207., 208.,
      229., 230., 233., 234., 237., 238., 239., 240., 245., 246., 249., 250.,
      253., 254., 255., 256., 293., 294., 297., 298., 301., 302., 303., 304.,
      325., 326., 329., 330., 333., 334., 335., 336., 357., 358., 361., 362.,
      365., 366., 367., 368., 373., 374., 377., 378., 381., 382., 383., 384.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  41.,  42.,  45.,  46.,  69.,  70.,  73.,  74.,  77.,
      78.,  101., 102., 105., 106., 109., 110., 165., 166., 169., 170.,
      173., 174., 197., 198., 201., 202., 205., 206., 229., 230., 233.,
      234., 237., 238., 293., 294., 297., 298., 301., 302., 325., 326.,
      329., 330., 333., 334., 357., 358., 361., 362., 365., 366.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, SAME3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  137., 138., 139., 140., 145., 146., 147., 148.,
      153., 154., 155., 156., 157., 158., 159., 160., 201., 202., 203., 204.,
      209., 210., 211., 212., 217., 218., 219., 220., 221., 222., 223., 224.,
      233., 234., 235., 236., 241., 242., 243., 244., 249., 250., 251., 252.,
      253., 254., 255., 256., 329., 330., 331., 332., 337., 338., 339., 340.,
      345., 346., 347., 348., 349., 350., 351., 352., 393., 394., 395., 396.,
      401., 402., 403., 404., 409., 410., 411., 412., 413., 414., 415., 416.,
      457., 458., 459., 460., 465., 466., 467., 468., 473., 474., 475., 476.,
      477., 478., 479., 480., 489., 490., 491., 492., 497., 498., 499., 500.,
      505., 506., 507., 508., 509., 510., 511., 512., 585., 586., 587., 588.,
      593., 594., 595., 596., 601., 602., 603., 604., 605., 606., 607., 608.,
      649., 650., 651., 652., 657., 658., 659., 660., 665., 666., 667., 668.,
      669., 670., 671., 672., 713., 714., 715., 716., 721., 722., 723., 724.,
      729., 730., 731., 732., 733., 734., 735., 736., 745., 746., 747., 748.,
      753., 754., 755., 756., 761., 762., 763., 764., 765., 766., 767., 768.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow3Stride2Forward, VALID3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,  89.,  90.,  91.,  92.,
      137., 138., 139., 140., 145., 146., 147., 148., 153., 154., 155., 156.,
      201., 202., 203., 204., 209., 210., 211., 212., 217., 218., 219., 220.,
      329., 330., 331., 332., 337., 338., 339., 340., 345., 346., 347., 348.,
      393., 394., 395., 396., 401., 402., 403., 404., 409., 410., 411., 412.,
      457., 458., 459., 460., 465., 466., 467., 468., 473., 474., 475., 476.,
      585., 586., 587., 588., 593., 594., 595., 596., 601., 602., 603., 604.,
      649., 650., 651., 652., 657., 658., 659., 660., 665., 666., 667., 668.,
      713., 714., 715., 716., 721., 722., 723., 724., 729., 730., 731., 732.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
